import { defineStore } from 'pinia';
import { getList as getTagList,getDetail} from '@/api/media/bizTagsController';


// 定义标签类型（与后端BizTags一致）
export interface Tag {
    id: number;
    name: string;
    createTime?: string;
    updateTime?: string;
    deleted?: number;
    sort?: number; // 用于排序（如热门标签）
}

// 定义 Store 类型
interface TagState {
    tags: Tag[]; // 存储所有标签
    isLoading: boolean; // 加载状态
    error: string | null; // 错误信息
}

// 创建 Pinia Store
export const useTagStore = defineStore('tag', {
    state: (): TagState => ({
        tags: [],
        isLoading: false,
        error: null,
    }),

    getters: {
        // 热门标签（例如取排序前5的标签）
        hotTags: (state) => {
            return [...state.tags]
                .sort((a, b) => (b.sort || 0) - (a.sort || 0))
                .slice(0, 5);
        },

        // 根据ID查找标签
        getTagById: (state) => (id: number) => {
            return state.tags.find(tag => tag.id === id);
        },
    },

    actions: {
        // 从接口查询所有标签并保存到 Pinia
        async fetchAndSaveTags() {
            this.isLoading = true;
            this.error = null;
            try {
                const response = await getTagList();
                if (response.code === '00000' && response.data) {
                    this.tags = response.data;
                } else {
                    this.error = response.message || '获取标签失败';
                }
            } catch (err) {
                this.error = '获取标签时发生错误';
                console.error('标签查询失败:', err);
            } finally {
                this.isLoading = false;
            }
        },

        // 根据ID列表获取标签详情
        async fetchTagsByIds(ids: number[]): Promise<Tag[]> {
            // 如果没有ID，返回空数组
            if (!ids || ids.length === 0) {
                return [];
            }

            this.isLoading = true;
            this.error = null;

            try {
                // 调用接口，参数为逗号分隔的ID字符串
                const response = await getDetail({
                    ids: ids.join(',')
                });

                if (response.code === '00000' && response.data) {
                    // 更新本地存储的标签（合并新数据）
                    response.data.forEach((tag: Tag) => {
                        const existingIndex = this.tags.findIndex(t => t.id === tag.id);
                        if (existingIndex > -1) {
                            this.tags[existingIndex] = tag;
                        } else {
                            this.tags.push(tag);
                        }
                    });

                    return response.data;
                } else {
                    this.error = response.message || '获取标签详情失败';
                    return [];
                }
            } catch (err) {
                this.error = '获取标签详情时发生错误';
                console.error('标签详情查询失败:', err);
                return [];
            } finally {
                this.isLoading = false;
            }
        },

        // 新增标签并更新到 Pinia
        addTag(newTag: Tag) {
            if (!this.tags.some(tag => tag.id === newTag.id || tag.name === newTag.name)) {
                this.tags.push(newTag);
            }
        },

        // 批量新增标签
        batchAddTags(newTags: Tag[]) {
            newTags.forEach(tag => this.addTag(tag));
        },

        // 根据ID删除标签（本地）
        removeTagById(id: number) {
            this.tags = this.tags.filter(tag => tag.id !== id);
        },
    },
});
